#!/bin/bash

#
# Primer Cuatrimestre 2013 - Grupo 08
#
# Comando: InstalY.sh
# Descripcion: realiza la instalacion de los componentes necesarios para el correcto funcionamiento.
#
#***************************************************************************
# $1: Comando
# $2: Tipo
# $3: Mensaje
loguear(){
	# Registra el mensaje
	"$CONFDIR"/GlogY.sh "InstalY" "$1" "$2" 

	# Verifica si se muestra por pantalla el log
	if [ -z "$3" ]
	then 
		echo -e "$2"
	fi
} 
# $1: Path Origen
# $2: Path Destino
mover() {
	cp "$1" "$2"
}
########## VALIDACIONES ##########
# $1: Path a validar
# $2: Path por defecto
validarPath () {
	local dir_a_validar="$1"
	local dir_default="$2"

	dir_a_validar="`echo "$dir_a_validar" | sed 's/^\(\/\|\.\|~\/\)\+//'`" 	# Se eliminan los posibles caracteres de comienzo de acceso relativo al inicio ('/' o '.' o '~/')
	dir_a_validar="`echo "$dir_a_validar" | sed 's/\/\{2,\}/\//g'`" 	# Se transforman las posibles multiples ocurrencias de '/' a uno solo
	dir_a_validar="`echo "$dir_a_validar" | sed 's/\/\+$//g'`" 		# Se elimina el ultimo '/'

	if [ -z "$dir_a_validar" ]
	then
		PATH_VALIDO=$dir_default
	else
		# Se valida que no tenga "/./" o "/../" o combinaciones de estas luego de un caracter distinto al "."
		while [ ! -z "`echo "$dir_a_validar" | grep -o '[^\.]\(\/\.\.\?\/\)\+'`" ]
		do
			loguear "I" "Usted ingresó una dirección inválida. Por favor ingrese nuevamente: \\c"
			read dir_a_validar
			loguear "I" "$dir_a_validar" "N"
			dir_a_validar="`echo "$dir_a_validar" | sed 's/^\(\/\|\.\|~\/\)\+//'`"
			dir_a_validar="`echo "$dir_a_validar" | sed 's/\/\{2,\}/\//g'`"
			dir_a_validar="`echo "$dir_a_validar" | sed 's/\/\+$//g'`"
		done

		if [ -z "$dir_a_validar" ]
		then
			PATH_VALIDO=$dir_default
		else
			PATH_VALIDO="$GRUPO/$dir_a_validar"
		fi
	fi
}

# $1: Tamaño a validar
# $2: Tamaño por defecto
validarTamanioArchivo () {
	local tamanio="$1"
	local default="$2"
	local valido=""

	while [ -z "$valido" -a ! -z "$tamanio" ]
	do
		if [ ! -z "`echo "$tamanio" | grep '[^0-9]\{1,\}'`" ]
		then
			loguear "I" "La variable ingresada no es valida. Ingrese solo numeros: \\c"
			read tamanio
			loguear "I" "$tamanio" "N"
		else
			valido="true"
		fi
	done

	if [ -z "$tamanio" ]
	then
		TAMANIO_VALIDADO="$2"
	else
		TAMANIO_VALIDADO="$tamanio"
	fi
}

#***************************************************************************
# PASO 1: Inicializar Archivo Log
inicializarArchivoLog(){
	loguear "I" "Inicio de Ejecucion" "N"
}
#***************************************************************************
# PASO 4: Verificacion de componentes instalados
#
# $1: Nombre Componente
# $2: Fecha Instalacion
#
existeComponente(){
	if [ $2 -eq 1 ]
	then 
		echo "\n* <"$1">\t\t\t\t\t\t\t*"
	fi
}
# $1: Nombre Componente
# $2: Fecha Actual
#
noExisteComponente(){
	if [ $2 -eq 0 ]
	then 
		echo "\n* <"$1">\t\t\t\t\t\t\t*"
	fi
}
# $1: Tipo cancelacion
# 
msgInstalacionCancelada(){
	loguear "$1" "Proceso de Instalacion Cancelado.";
	exit 1;
}

msgInstalacionYaRealizada(){
	msgInstalacionCompleta
	msgInstalacionCancelada "I"
}

msgInstalacionCompleta(){
	loguear "I" "***************************************************"
	loguear "I" "TP SO7508 Primer Cuatrimestre 2013. Tema Y Copyright (c) Grupo 08"
	loguear "I" "Instalacion Concluida"
	loguear "I" "***************************************************"
}

msgInstalacionIncompleta(){
	local lista_instalados="`existeComponente "InicioY.sh" $inicioY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "DetectaY.sh" $detectaY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "ReporteY.pl" $reporteY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "Interprete.sh" $interprete_inst`"
	lista_instalados=$lista_instalados"`existeComponente "MoverY.sh" $moverY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "StartY.sh" $startY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "StopY.sh" $stopY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "GlogY.sh" $glogY_inst`"
	lista_instalados=$lista_instalados"`existeComponente "VlogY.sh" $vlogY_inst`"

	local lista_no_instalados="`noExisteComponente "InicioY.sh" $inicioY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "DetectaY.sh" $detectaY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "ReporteY.pl" $reporteY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "Interprete.sh" $interprete_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "MoverY.sh" $moverY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "StartY.sh" $startY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "StopY.sh" $stopY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "GlogY.sh" $glogY_inst`"
	lista_no_instalados=$lista_no_instalados"`noExisteComponente "VlogY.sh" $vlogY_inst`"

	loguear "I" "***************************************************"
	loguear "I" "TP SO7508 Primer Cuatrimestre 2013. Tema Y Copyright (c) Grupo 08"
	loguear "I" "***************************************************"
	loguear "I" "Se encuentran instalados los siguientes componentes: "
	loguear "I" "$lista_instalados"
	loguear "I" "Falta instalar los siguientes componentes: "
	loguear "I" "$lista_no_instalados"
	loguear "I" "****************************************************"
}
#
verificarExistenciaComponentes(){
	for componente in $(ls -1 $1)
	do
		if [ "InicioY.sh" = "$componente" ];
		then 
			inicioY_inst=1
			INICIOF="`cat "$INSTALY_CONF" | grep 'INICIOF' | cut -f2 -d\=`"
			INICIOU="`cat "$INSTALY_CONF" | grep 'INICIOU' | cut -f2 -d\=`"
		elif [ "DetectaY.sh" = "$componente" ];
		then
			detectaY_inst=1
			DETECTAF="`cat "$INSTALY_CONF" | grep 'DETECTAF' | cut -f2 -d\=`"
			DETECTAU="`cat "$INSTALY_CONF" | grep 'DETECTAU' | cut -f2 -d\=`"
		elif [ "Interprete.sh" = "$componente" ];
		then
			interprete_inst=1
		elif [ "ReporteY.pl" = "$componente" ];
		then 
			reporteY_inst=1
			REPORTEF="`cat "$INSTALY_CONF" | grep 'REPORTEF' | cut -f2 -d\=`"
			REPORTEU="`cat "$INSTALY_CONF" | grep 'REPORTEU' | cut -f2 -d\=`"
		elif [ "MoverY.sh" = "$componente" ];
		then 
			moverY_inst=1
		elif [ "GlogY.sh" = "$componente" ];
		then 	
			glogY_inst=1
		elif [ "StartY.sh" = "$componente" ];
		then 
			startY_inst=1
		elif [ "VlogY.sh" = "$componente" ];
		then 
			vlogY_inst=1	
		elif [ "StopY.sh" = "$componente" ];
		then 
			stopY_inst=1
		fi
	done
	
	if [ $reporteY_inst -eq 1] && [ $detectaY_inst -eq 1 ] && [ $inicioY_inst -eq 1 ] && [ $moverY_inst -eq 1 ] && [ $glogY_inst -eq 1 ] && [ $vlogY_inst -eq 1 ]&& [ $startY_inst -eq 1 ] && [ $stopY_inst -eq 1 ]; then
		# Existen
		msgInstalacionYaRealizada
		exit 1;
	else 
		# No existen todos los componentes
		msgInstalacionIncompleta
	fi	
}

validarInstalacion(){
	utils_inst=0
	stopY_inst=0
	startY_inst=0
	glogY_inst=0
	vlogY_inst=0
	moverY_inst=0
	reporteY_inst=0
	detectaY_inst=0
	inicioY_inst=0
	interprete_inst=0
	if [ -f "$INSTALY_CONF" ]
	then
		# Obtengo valor de BINDIR del archivo de configuracion
		bindir_configurado="`cat "$INSTALY_CONF" | grep 'BINDIR' | cut -f2 -d\=`"

		# Verifico que el valor de BINDIR exista
		if ( ! [ -z "$bindir_configurado" ] )
		then 
			loguear "I" "El archivo de configuracion existe y hay un bin configurado" 
			verificarExistenciaComponentes "$bindir_configurado"
		else 
			loguear "I" "El archivo de configuracion existe pero no hay un bin configurado" "N"
			loguear "I" "El instalador detecto que existe el archivo de configuracion pero esta incompleto" 
			msgInstalacionCancelada "ES"
		fi
	else 
		loguear "I" "No existe el archivo de configuracion" "N"
		loguear "I" "Verificacion correcta para comenzar con la instalacion" 
	fi
	clear
}
#***************************************************************************
# PASO 5: Aceptacion de terminos y condiciones
#
msgTerminosyCondiciones(){
	loguear "I" "******************************************************"
	loguear "I" "TP SO7508 Primer Cuatrimestre 2013. Tema Y Copyright (c) Grupo08"
	loguear "I" "ATENCION: Al instalar TP SO7508 Primer Cuatrimestre 2013 UD. "
	loguear "I" "expresa aceptar los terminos y Condiciones del \"ACUERDO DE LICENCIA DE "
	loguear "I" "SOFTWARE\" incluido en este paquete."
	loguear "I" "********************************************************"
	loguear "I" "Pulse \"A\" para aceptar, \"C\" para cancelar: \\c"
}

consultarLicencia(){
	msgTerminosyCondiciones
	local respuesta=""
	read respuesta
	loguear "I" "$respuesta" "N"

	# Verifico si es opcion correcta
	while [ "$respuesta" != "A" -a "$respuesta" != "C" ]
	do 
		loguear "I" "Opcion Invalida"
		loguear "I" "Por favor, ingrese \"A\" para aceptar, \"C\" para cancelar: \\c"
		read respuesta
		loguear "I" "$respuesta" "N"
	done 
	if [ "$respuesta" = "C" ]
	then 
		msgInstalacionCancelada "I"
	fi
}
#***************************************************************************
# PASO 6: Chequear que Perl este instalado
#
msgErrorPerl(){
	loguear "SE" "Para instalar el TP es necesario contar con Perl 5 o superior"
	loguear "SE" "instalado. Efectue su instalacion e intentelo nuevamente."
	msgInstalacionCancelada "ES";
}

validarInstalacionPerl(){
	is_perl=`whereis perl`
	if [ "$is_perl" != "perl: " ] 
	then
		local perl_release=`perl --version | grep 'v[0-9]\.' | sed "s/.*v\([^.]\).*/\1/"`
		if [ $perl_release -ge 5 ]
		then
			loguear "I" "Perl version: $perl_release"
		else
			msgErrorPerl;
		fi
	else
		msgErrorPerl;
	fi
}
#***************************************************************************
# PASO 7: Definir directorio de instalacion de los ejecutables
#
definirDirectorioEjecutables(){
	local default="$BINDIR"
	loguear "I" "Defina el directorio de instalacion de los ejecutables ($BINDIR): \\c"
	read BINDIR
	loguear "I" "$BINDIR" "N"
	validarPath "$BINDIR" "$default"
	BINDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 8: Definir directorio de instalacion de los maestros
#
definirDirectorioMaestros(){
	local default="$MAEDIR"
	loguear "I" "Defina el directorio de instalacion de los archivos maestros ($MAEDIR): \\c"
	read MAEDIR
	loguear "I" "$MAEDIR" "N"
	validarPath "$MAEDIR" "$default"
	MAEDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 9: Definir directorio de arribo de archivos externos
#
definirDirectorioArriboArchivos(){
	local default="$ARRIDIR"
	loguear "I" "Defina el directorio de arribo de archivos externos ($ARRIDIR): \\c"
	read ARRIDIR
	loguear "I" "$ARRIDIR" "N"
	validarPath "$ARRIDIR" "$default"
	ARRIDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 10: Definir espacio minimo libre para el arribo de archcivos externos
#
definirEspacioMinimoDatos(){
	local default="$DATASIZE"
	loguear "I" "Defina el espacio minimo libre para el arribo de archivos externos en Mbytes ($DATASIZE): \\c"
	read DATASIZE
	loguear "I" "$DATASIZE" "N"
	validarTamanioArchivo "$DATASIZE" "100"
	DATASIZE="$TAMANIO_VALIDADO"
}
#***************************************************************************
# PASO 11: Verificar espacio en disco
#
verificarEspacioEnDisco(){
	local espacio_disponible=`df -BM . | sed 's/ \+/,/g' | cut -f4 -d, | tail -1 | sed 's/M//'`
	
	if [ $espacio_disponible -lt $DATASIZE ]
	then
		loguear "SE" "Insuficiente espacio en disco."
		loguear "SE" "Espacio disponible: $espacio_disponible Mb. "
		loguear "SE" "Espacio requerido $DATASIZEMb."
		loguear "SE" "Cancele la instalacion o intentelo mas tarde o vuelva a intentarlo"
		loguear "SE" "con otro valor."
		loguear "SE" ""
		definirEspacioMinimoDatos;
	fi
}
#***************************************************************************
# PASO 12: Definir directorio de grabacion de archivos rechazados
#
definirDirectorioRechazados(){
	local default="$RECHDIR"
	loguear "I" "Defina el directorio de grabacion de los archivos externos rechazados ($RECHDIR): \\c"
	read RECHDIR
	loguear "I" "$RECHDIR" "N"
	validarPath "$RECHDIR" "$default"
	RECHDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 13: Definir directorio de grabacion de los archivos aceptados
#
definirDirectorioAceptados(){
	local default="$ACEPDIR"
	loguear "I" "Defina el directorio de grabacion de los archivos aceptados ($ACEPDIR): \\c"
	read ACEPDIR
	loguear "I" "$ACEPDIR" "N"
	validarPath "$ACEPDIR" "$default"
	ACEPDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 14: Definir directorio de trabajo principal del proceso interprete
#
definirDirectorioInterprete(){
	local default="$PROCDIR"
	loguear "I" "Defina el directorio de grabacion de los archivos procesados ($PROCDIR): \\c"
	read PROCDIR
	loguear "I" "$PROCDIR" "N"
	validarPath "$PROCDIR" "$default"
	PROCDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 15: Definir directorio de grabacion de los reportes de salida
#
definirDirectorioReporte(){
	local default="$REPODIR"
	loguear "I" "Defina el directorio de grabacion de los reportes de salida ($REPODIR): \\c"
	read REPODIR
	loguear "I" "$REPODIR" "N"
	validarPath "$REPODIR" "$default"
	REPODIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 16: Definir directorio de logs para los comandos
#
definirDirectorioArchivosLog(){
	local default="$LOGDIR"
	loguear "I" "Defina el directorio de logs ($LOGDIR): \\c"
	read LOGDIR
	loguear "I" "$LOGDIR" "N"
	validarPath "$LOGDIR" "$default"
	LOGDIR="$PATH_VALIDO"
}
#***************************************************************************
# PASO 17: Definir la extension para los archivos de log
#
definirExtensionArchivosLog(){
	local default="$LOGEXT"
	loguear "I" "Ingrese la extension para los archivos de log ($LOGEXT): \\c"
	read LOGEXT
	loguear "I" "$LOGEXT" "N"
	if [ -z $LOGEXT ]
	then
		LOGEXT="$default"
	else
		LOGEXT=`echo $LOGEXT | sed 's/^\.\+//'`
	fi
}
#***************************************************************************
# PASO 18: Definir el tamaño maximo para los archivos de log
#
definirTamanioArchivosLog(){
	local default="$LOGSIZE"
	loguear "I" "Defina el tamaño maximo para los archivos $LOGEXT en Kbytes: ($LOGSIZE) \\c"
	read LOGSIZE
	loguear "I" "$LOGSIZE" "N"
	validarTamanioArchivo "$LOGSIZE" "400"
	LOGSIZE="$TAMANIO_VALIDADO"
}
#***************************************************************************
# PASO 19: Mostrar estructura directorios resultante y parametros configurados
#
mostrarEstructuraParametros(){
	loguear "I" "********************************************************"
	loguear "I" "TP SO7508 Primer Cuatrimestre 2013. Tema Y Copyright (c) Grupo08"
	loguear "I" "Libreria del Sistema: $CONFDIR"
	loguear "I" "Ejecutables: $BINDIR" 
	loguear "I" "Archivos Maestros: $MAEDIR"
	loguear "I" "Directorio de arribo de archivos externos: $ARRIDIR"
	loguear "I" "Espacio minimo libre para arribos: $DATASIZE MB"
	loguear "I" "Archivos externos aceptados: $ACEPDIR"
	loguear "I" "Archivos externos rechazados: $RECHDIR"
	loguear "I" "Archivos procesados: $PROCDIR"
	loguear "I" "Reportes de salida: $REPODIR"
	loguear "I" "Logs de auditoria del sistema: $LOGDIR/<comando>.$LOGEXT"
	loguear "I" "Tamaño maximo para los archivos de log del sistema: $LOGSIZE Kb"
	loguear "I" "Estado de la instalacion: LISTA"
	loguear "I" "Si los datos ingresados son correctos oprima solo ENTER para iniciar la instalación."
	loguear "I" "Si desea modificar alguno de ellos oprima cualquier tecla."
	loguear "I" "************************************************************************"
}
#***************************************************************************
# PASO 20: Confirmar inicio de instalacion
#
confirmarInicioInstalacion(){
	loguear "I" "Iniciando Instalacion... Esta Ud. seguro? (S/N) \\c"
	read respuesta
	loguear "I" "$respuesta" "N"
	
	while [ "$respuesta" != "S" -a "$respuesta" != "N" ]
	do
		loguear "I" "La opcion ingresada es incorrecta. Ud esta seguro de proseguir con la instalacion? (S/N) \\c"
		read respuesta
		loguear "I" "$respuesta" "N"
	done 
	
	if [ "$respuesta" = "N" ]
	then
		msgInstalacionCancelada "I"
	fi
}
#***************************************************************************
# PASO 21: Instalacion
#
crearEstructurasDeDirectorio(){
	loguear "I" "Creando Estructuras de Directorio..."

	mkdir -p "$BINDIR"
	loguear "I" "Creacion de directorio de archivos ejecutables ($BINDIR) OK"	

	mkdir -p "$MAEDIR"
	loguear "I" "Creacion de directorio de archivos maestros ($MAEDIR) OK"

	mkdir -p "$ARRIDIR"
	loguear "I" "Creacion de directorio de arribos ($ARRIDIR) OK"

	mkdir -p "$RECHDIR"
	loguear "I" "Creacion de directorio de rechazados ($RECHDIR) OK"
	
	mkdir -p "$ACEPDIR"
	loguear "I" "Creacion de directorio de aceptados ($ACEPDIR) OK"
	
	mkdir -p "$PROCDIR"
	loguear "I" "Creacion de directorio de procesados ($PROCDIR) OK"

	mkdir -p "$LOGDIR"
	loguear "I" "Creacion de directorio de logs ($LOGDIR) OK"

	mkdir -p "$REPODIR"
	loguear "I" "Creacion de directorio de reportes ($REPODIR) OK"
}

moverArchivos(){
	loguear "I" "Instalando Programas y Funciones"

	# mover archivos de la carpeta lib a bin
	if [ $inicioY_inst -eq 0 ]; then
		mover "$LIBDIR/InicioY.sh" "$BINDIR"
		INICIOF=`date "+%d-%m-%Y %H:%M.%N"`
		INICIARU=$USUARIO 
		loguear "I" "Archivo InicioY copiado OK"
	fi

	if [ $detectaY_inst -eq 0 ]; then
		mover "$LIBDIR/DetectaY.sh" "$BINDIR"
		DETECTAF=`date "+%d-%m-%Y %H:%M.%N"` 	
		DETECTAU=$USUARIO 
		loguear "I" "Archivo DetectaY copiado OK"
	fi
	if [ $interprete_inst -eq 0 ]; then
		mover "$LIBDIR/Interprete.sh" "$BINDIR"
		loguear "I" "Archivo Interprete copiado OK"
	fi

	if [ $reporteY_inst -eq 0 ]; then
		mover "$LIBDIR/ReporteY.pl" "$BINDIR"
		loguear "I" "Archivo ReporteY copiado OK"
	fi

	if [ $moverY_inst -eq 0 ]; then
		mover "$LIBDIR/MoverY.sh" "$BINDIR"
		loguear "I" "Archivo MoverY copiado OK"
	fi

	if [ $startY_inst -eq 0 ]; then
		mover "$LIBDIR/StartY.sh" "$BINDIR"
		loguear "I" "Archivo StartY copiado OK"
	fi

	if [ $stopY_inst -eq 0 ]; then
		mover "$LIBDIR/StopY.sh" "$BINDIR"
		loguear "I" "Archivo StopY copiado OK"
	fi

	if [ $vlogY_inst -eq 0 ]; then
		mover "$LIBDIR/VlogY.sh" "$BINDIR"
		loguear "I" "Archivo VlogY copiado OK"
	fi

	mover "$CONFDIR/GlogY.sh" "$BINDIR"
	loguear "I" "Archivo GlogY copiado OK"
	

	loguear "I" "Instalando archivos maestros"
	# mover maestros de inst a mae

	mover "$INSTDIR/PPI.mae" "$MAEDIR"
	loguear "I" "Archivo PPI.mae copiado OK"

	mover "$INSTDIR/p-s.mae" "$MAEDIR"
	loguear "I" "Archivo PPI.mae copiado OK"
	
	loguear "I" "Instalando Tablas de Configuracion"
	
	# mover tablas de inst a confdir
	mover "$INSTDIR/T2.tab" "$CONFDIR"
	loguear "I" "Archivo T2.tab copiado OK"

	mover "$INSTDIR/T1.tab" "$CONFDIR"
	loguear "I" "Archivo T1.tab copiado OK"
}

actualizarArchivoConfiguracion(){
 	loguear "I" "Actualizando la configuracion del sistema"
	
	# Se borra la configuracion anterior en caso que exista
	if [ -f "$INSTALY_CONF" ]
	then 
		rm "$INSTALY_CONF"
	fi

	# Genero nuevo archivo configuracion
	echo "GRUPO=$GRUPO">>"$INSTALY_CONF"
	echo "CONFDIR=$CONFDIR">>"$INSTALY_CONF"
	echo "BINDIR=$BINDIR">>"$INSTALY_CONF"
	echo "MAEDIR=$MAEDIR">>"$INSTALY_CONF"
	echo "ARRIDIR=$ARRIDIR">>"$INSTALY_CONF"
	echo "ACEPDIR=$ACEPDIR">>"$INSTALY_CONF"
	echo "RECHDIR=$RECHDIR">>"$INSTALY_CONF"
	echo "PROCDIR=$PROCDIR">>"$INSTALY_CONF"
	echo "REPODIR=$REPODIR">>"$INSTALY_CONF"
	echo "LOGDIR=$LOGDIR">>"$INSTALY_CONF"					
	echo "LOGEXT=$LOGEXT">>"$INSTALY_CONF"
	echo "LOGSIZE=$LOGSIZE">>"$INSTALY_CONF"	
	echo "DATASIZE=$DATASIZE">>"$INSTALY_CONF"
	echo "">>"$INSTALY_CONF"	
	
	loguear "I" "Archivo de Configuracion Actualizado satisfactoriamente."
}

instalar(){
	crearEstructurasDeDirectorio
	moverArchivos
	actualizarArchivoConfiguracion
}
#***************************************************************************
# PASO 23: Mostrar Fin instalacion 
#
mostrarFinInstalacion(){
	msgInstalacionCompleta
}

#***************************************************************************
# INICIO SCRIPT
#

CURRDIR=$(dirname "$(readlink -m "$0")")
USUARIO=`whoami`

GRUPO=${CURRDIR%/*}

INSTDIR="$GRUPO/inst"
LIBDIR="$GRUPO/lib"
CONFDIR="$GRUPO/conf"
BINDIR="$GRUPO/bin"
MAEDIR="$GRUPO/mae"
ARRIDIR="$GRUPO/arribos"
ACEPDIR="$GRUPO/aceptados"	
RECHDIR="$GRUPO/rechazados"
LOGDIR="$GRUPO/log"
PROCDIR="$GRUPO/procesados"
REPODIR="$GRUPO/reportes"
LOGEXT="log"
LOGSIZE="400"
DATASIZE="100"
INICIOF=""
DETECTAF=""
REPORTEF=""
INICIOU=""
DETECTAU=""
REPORTEU=""

INSTALY_LOG="$CONFDIR/InstalY.log"
INSTALY_CONF="$CONFDIR/InstalY.conf"

# Setear permiso de ejecucion al log
chmod +x "$CONFDIR"/GlogY.sh

# Exporta variables para log inicial
export INSTALY_LOG

# Main
inicializarArchivoLog
validarInstalacion

if [ -z $bindir_configurado ]; then
	consultarLicencia
	validarInstalacionPerl
	ACEPTO_TERMINOS="a"
	while [ ! -z "$ACEPTO_TERMINOS" ]
	do
		definirDirectorioEjecutables
		definirDirectorioMaestros
		definirDirectorioArriboArchivos
		definirEspacioMinimoDatos
		verificarEspacioEnDisco
		definirDirectorioRechazados
		definirDirectorioAceptados
		definirDirectorioInterprete
		definirDirectorioReporte
		definirDirectorioArchivosLog
		definirExtensionArchivosLog
		definirTamanioArchivosLog
		mostrarEstructuraParametros
		read ACEPTO_TERMINOS
		loguear "I" "$ACEPTO_TERMINOS" "N"
	done
else 
	CONFDIR=$(grep 'CONFDIR*' $INSTALY_CONF | cut -f2 -d\=)
	BINDIR=$(grep 'BINDIR*' $INSTALY_CONF | cut -f2 -d\=)  
	MAEDIR=$(grep 'MAEDIR*' $INSTALY_CONF | cut -f2 -d\=) 
	ARRIDIR=$(grep 'ARRIDIR*' $INSTALY_CONF | cut -f2 -d\=)
	DATASIZE=$(grep 'DATASIZE*' $INSTALY_CONF | cut -f2 -d\=)
	ACEPDIR=$(grep 'ACEPDIR*' $INSTALY_CONF | cut -f2 -d\=) 
	RECHDIR=$(grep 'RECHDIR*' $INSTALY_CONF | cut -f2 -d\=) 
	PROCDIR=$(grep 'PROCDIR*' $INSTALY_CONF | cut -f2 -d\=) 
	REPODIR=$(grep 'REPODIR*' $INSTALY_CONF | cut -f2 -d\=) 
	LOGDIR=$(grep 'LOGDIR*' $INSTALY_CONF | cut -f2 -d\=)
	LOGEXT=$(grep 'LOGEXT*' $INSTALY_CONF | cut -f2 -d\=)
	LOGSIZE=$(grep 'LOGSIZE*' $INSTALY_CONF | cut -f2 -d\=)

	mostrarEstructuraParametros
	read ACEPTO_TERMINOS
	loguear "I" "$ACEPTO_TERMINOS" "N"
fi

confirmarInicioInstalacion
instalar
mostrarFinInstalacion

exit 0
# FIN SCRIPT
#***************************************************************************
#
